/* 
 * $Id: EditorRuler.java,v 1.2 2009/11/24 12:00:28 gaudenz Exp $
 * Copyright (c) 2001-2005, Gaudenz Alder
 * 
 * All rights reserved.
 * 
 * See LICENSE file for license details. If you are unable to locate
 * this file please contact info (at) jgraph (dot) com.
 */
package com.magnificent.panda.ui.editor;

import com.magnificent.graph.util.mxEvent;
import com.magnificent.graph.util.mxEventObject;
import com.magnificent.graph.util.mxEventSource.mxIEventListener;
import com.magnificent.graph.util.mxPoint;
import com.magnificent.graph.view.mxGraph;
import com.magnificent.panda.ui.GraphComponent;

import javax.swing.*;
import java.awt.*;
import java.awt.dnd.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.text.NumberFormat;
import java.util.TooManyListenersException;

/**
 * Component that displays a ruler for a JGraph component.
 */
public class EditorRuler extends JComponent implements MouseMotionListener,
        DropTargetListener {

    /**
     *
     */
    private static final long serialVersionUID = -6310912355878668096L;

    /**
     * Defines the constants for horizontal and vertical orientation.
     */
    public static int ORIENTATION_HORIZONTAL = 0, ORIENTATION_VERTICAL = 1;

    /**
     * Internal constant used to describe the screen resolution (DPI). Default
     * is 72.
     */
    protected static int INCH = 72;

    /**
     * Internal constant used to describe the screen resolution (DPI). Default
     * is 72.
     */
    protected static int DEFAULT_PAGESCALE = 1;

    /**
     * Internal constant used to describe the screen resolution (DPI). Default
     * is 72.
     */
    protected static boolean DEFAULT_ISMETRIC = true;

    /**
     * Holds the shared number formatter.
     *
     * @see NumberFormat#getInstance()
     */
    public static final NumberFormat numberFormat = NumberFormat.getInstance();

    /**
     * Configuers the number format.
     */
    static {
        numberFormat.setMaximumFractionDigits(2);
    }

    /**
     * Defines the inactive background border. Default is a not-so-dark gray.
     */
    protected Color inactiveBackground = new Color(170, 170, 170);

    /**
     * Specifies the orientation.
     */
    protected int orientation = ORIENTATION_HORIZONTAL;

    /**
     * Specified that start and length of the active region, ie the region to
     * paint with the background border. This is used for example to indicate
     * the printable region of a graph.
     */
    protected int activeoffset, activelength;

    /**
     * Specifies the scale for the metrics. Default is
     * {@link JGraphEditorDiagramPane#DEFAULT_PAGESCALE}.
     */
    protected double scale = DEFAULT_PAGESCALE;

    /**
     * Specifies the unit system. Default is
     * {@link JGraphEditorDiagramPane#DEFAULT_ISMETRIC}.
     */
    protected boolean metric = DEFAULT_ISMETRIC;

    /**
     *
     */
    protected Font labelFont = new Font("Tahoma", Font.PLAIN, 9);

    /**
     * Specifies height or width of the ruler. Default is 15 pixels.
     */
    protected int rulerSize = 16;

    /**
     * Specifies the minimum distance between two major ticks. Default is 30.
     */
    protected int tickDistance = 30;

    /**
     * Reference to the attached graph.
     */
    protected GraphComponent graphComponent;

    /**
     * Holds the current and first mouse point.
     */
    protected Point mouse = new Point();

    /**
     * Parameters to control the display.
     */
    protected double increment, units;

    /**
     *
     */
    protected transient mxIEventListener repaintHandler = new mxIEventListener() {
        public void invoke(Object source, mxEventObject evt) {
            repaint();
        }
    };

    /**
     * Constructs a new ruler for the specified graph and orientation.
     *
     * @param graph       The graph to create the ruler for.
     * @param orientation The orientation to use for the ruler.
     */
    public EditorRuler(GraphComponent graphComponent, int orientation) {
        this.orientation = orientation;
        this.graphComponent = graphComponent;
        updateIncrementAndUnits();

        graphComponent.getGraph().getView().addListener(
                mxEvent.SCALE, repaintHandler);
        graphComponent.getGraph().getView().addListener(
                mxEvent.TRANSLATE, repaintHandler);
        graphComponent.getGraph().getView().addListener(
                mxEvent.SCALE_AND_TRANSLATE, repaintHandler);

        graphComponent.getGraphControl().addMouseMotionListener(this);

        DropTarget dropTarget = graphComponent.getDropTarget();

        try {
            if (dropTarget != null) {
                dropTarget.addDropTargetListener(this);
            }
        }
        catch (TooManyListenersException tmle) {
            // should not happen... ui drop target is multicast
        }

        setBorder(BorderFactory.createLineBorder(Color.black));
    }

    /**
     * Sets the start of the active region in pixels.
     *
     * @param offset The start of the active region.
     */
    public void setActiveOffset(int offset) {
        activeoffset = (int) (offset * scale);
    }

    /**
     * Sets the length of the active region in pixels.
     *
     * @param length The length of the active region.
     */
    public void setActiveLength(int length) {
        activelength = (int) (length * scale);
    }

    /**
     * Returns true if the ruler uses metric units.
     *
     * @return Returns if the ruler is metric.
     */
    public boolean isMetric() {
        return metric;
    }

    /**
     * Sets if the ruler uses metric units.
     *
     * @param isMetric Whether to use metric units.
     */
    public void setMetric(boolean isMetric) {
        this.metric = isMetric;
        updateIncrementAndUnits();
        repaint();
    }

    /**
     * Returns the ruler's horizontal or vertical size.
     *
     * @return Returns the rulerSize.
     */
    public int getRulerSize() {
        return rulerSize;
    }

    /**
     * Sets the ruler's horizontal or vertical size.
     *
     * @param rulerSize The rulerSize to set.
     */
    public void setRulerSize(int rulerSize) {
        this.rulerSize = rulerSize;
    }

    /**
     *
     */
    public void setTickDistance(int tickDistance) {
        this.tickDistance = tickDistance;
    }

    /**
     *
     */
    public int getTickDistance() {
        return tickDistance;
    }

    /**
     * Returns the preferred size by replacing the respective component of the
     * graph's preferred size with {@link #rulerSize}.
     *
     * @return Returns the preferred size for the ruler.
     */
    public Dimension getPreferredSize() {
        Dimension dim = graphComponent.getGraphControl().getPreferredSize();

        if (orientation == ORIENTATION_VERTICAL) {
            dim.width = rulerSize;
        } else {
            dim.height = rulerSize;
        }

        return dim;
    }

    /*
      * (non-Javadoc)
      * @see java.awt.dnd.DropTargetListener#dragEnter(java.awt.dnd.DropTargetDragEvent)
      */

    public void dragEnter(DropTargetDragEvent arg0) {
        // empty
    }

    /*
      * (non-Javadoc)
      * @see java.awt.dnd.DropTargetListener#dragExit(java.awt.dnd.DropTargetEvent)
      */

    public void dragExit(DropTargetEvent arg0) {
        // empty
    }

    /*
      * (non-Javadoc)
      * @see java.awt.dnd.DropTargetListener#dragOver(java.awt.dnd.DropTargetDragEvent)
      */

    public void dragOver(final DropTargetDragEvent arg0) {
        updateMousePosition(arg0.getLocation());
    }

    /*
      * (non-Javadoc)
      * @see java.awt.dnd.DropTargetListener#drop(java.awt.dnd.DropTargetDropEvent)
      */

    public void drop(DropTargetDropEvent arg0) {
        // empty
    }

    /*
      * (non-Javadoc)
      * @see java.awt.dnd.DropTargetListener#dropActionChanged(java.awt.dnd.DropTargetDragEvent)
      */

    public void dropActionChanged(DropTargetDragEvent arg0) {
        // empty
    }

    /*
      * (non-Javadoc)
      */

    public void mouseMoved(MouseEvent e) {
        updateMousePosition(e.getPoint());
    }

    /*
      * (non-Javadoc)
      */

    public void mouseDragged(MouseEvent e) {
        updateMousePosition(e.getPoint());
    }

    /**
     * Repaints the mouse position.
     */
    protected void updateMousePosition(Point pt) {
        Point old = mouse;
        mouse = pt;
        repaint(old.x, old.y);
        repaint(mouse.x, mouse.y);
    }

    /**
     * Updates the local variables used for painting based on the current scale
     * and unit system.
     */
    protected void updateIncrementAndUnits() {
        double graphScale = graphComponent.getGraph().getView().getScale();

        if (metric) {
            units = INCH / 2.54; // 2.54 dots per centimeter
            units *= graphComponent.getPageScale() * graphScale;
            increment = units;
        } else {
            units = INCH;
            units *= graphComponent.getPageScale() * graphScale;
            increment = units / 2;
        }
    }

    /**
     * Repaints the ruler between the specified 0 and x or y depending on the
     * orientation.
     *
     * @param x The endpoint for repainting a horizontal ruler.
     * @param y The endpoint for repainting a vertical ruler.
     */
    public void repaint(int x, int y) {
        if (orientation == ORIENTATION_VERTICAL) {
            repaint(0, y, rulerSize, 1);
        } else {
            repaint(x, 0, 1, rulerSize);
        }
    }

    /**
     * Paints the ruler.
     *
     * @param g The graphics to paint the ruler to.
     */
    public void paintComponent(Graphics g) {
        mxGraph graph = graphComponent.getGraph();
        Rectangle clip = g.getClipBounds();
        updateIncrementAndUnits();

        // Fills clipping area with background.
        if (activelength > 0 && inactiveBackground != null) {
            g.setColor(inactiveBackground);
        } else {
            g.setColor(getBackground());
        }

        g.fillRect(clip.x, clip.y, clip.width, clip.height);

        // Draws the active region.
        g.setColor(getBackground());
        Point2D p = new Point2D.Double(activeoffset, activelength);

        if (orientation == ORIENTATION_HORIZONTAL) {
            g.fillRect((int) p.getX(), clip.y, (int) p.getY(), clip.height);
        } else {
            g.fillRect(clip.x, (int) p.getX(), clip.width, (int) p.getY());
        }

        double left = clip.getX();
        double top = clip.getY();
        double right = left + clip.getWidth();
        double bottom = top + clip.getHeight();

        // Fetches some global display state information
        mxPoint trans = graph.getView().getTranslate();
        double scale = graph.getView().getScale();
        double tx = trans.getX() * scale;
        double ty = trans.getY() * scale;

        // Sets the distance of the grid lines in pixels
        double stepping = increment;

        if (stepping < tickDistance) {
            int count = (int) Math
                    .round(Math.ceil(tickDistance / stepping) / 2) * 2;
            stepping = count * stepping;
        }

        // Creates a set of strokes with individual dash offsets
        // for each direction
        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g.setFont(labelFont);
        g.setColor(Color.black);

        int smallTick = rulerSize - rulerSize / 3;
        int middleTick = rulerSize / 2;

        // TODO: Merge into a single drawing loop for both orientations
        if (orientation == ORIENTATION_HORIZONTAL) {
            double xs = Math.floor((left - tx) / stepping) * stepping + tx;
            double xe = Math.ceil(right / stepping) * stepping;
            xe += (int) Math.ceil(stepping);

            for (double x = xs; x <= xe; x += stepping) {
                // FIXME: Workaround for rounding errors when adding stepping to
                // xs or ys multiple times (leads to double grid lines when zoom
                // is set to eg. 121%)
                double xx = Math.round((x - tx) / stepping) * stepping + tx;

                int ix = (int) Math.round(xx);
                g.drawLine(ix, rulerSize, ix, 0);

                String text = format((x - tx) / increment);
                g.drawString(text, ix + 2, labelFont.getSize());

                ix += (int) Math.round(stepping / 4);
                g.drawLine(ix, rulerSize, ix, smallTick);

                ix += (int) Math.round(stepping / 4);
                g.drawLine(ix, rulerSize, ix, middleTick);

                ix += (int) Math.round(stepping / 4);
                g.drawLine(ix, rulerSize, ix, smallTick);
            }
        } else {
            double ys = Math.floor((top - ty) / stepping) * stepping + ty;
            double ye = Math.ceil(bottom / stepping) * stepping;
            ye += (int) Math.ceil(stepping);

            for (double y = ys; y <= ye; y += stepping) {
                // FIXME: Workaround for rounding errors when adding stepping to
                // xs or ys multiple times (leads to double grid lines when zoom
                // is set to eg. 121%)
                y = Math.round((y - ty) / stepping) * stepping + ty;

                int iy = (int) Math.round(y);
                g.drawLine(rulerSize, iy, 0, iy);

                String text = format((y - ty) / increment);

                // Rotates the labels in the vertical ruler
                AffineTransform at = ((Graphics2D) g).getTransform();
                ((Graphics2D) g).rotate(-Math.PI / 2, 0, iy);
                g.drawString(text, 1, iy + labelFont.getSize());
                ((Graphics2D) g).setTransform(at);

                iy += (int) Math.round(stepping / 4);
                g.drawLine(rulerSize, iy, smallTick, iy);

                iy += (int) Math.round(stepping / 4);
                g.drawLine(rulerSize, iy, middleTick, iy);

                iy += (int) Math.round(stepping / 4);
                g.drawLine(rulerSize, iy, smallTick, iy);
            }
        }

        // Draw Mouseposition
        g.setColor(Color.green);

        if (orientation == ORIENTATION_HORIZONTAL) {
            g.drawLine(mouse.x, rulerSize, mouse.x, 0);
        } else {
            g.drawLine(rulerSize, mouse.y, 0, mouse.y);
        }
    }

    /**
     * Fixes the formatting of -0.
     */
    private final String format(double value) {
        String text = numberFormat.format(value);

        if (text.equals("-0")) {
            text = "0";
        }

        return text;
    }

}
  /* converted to utf8 */